15. Java avanzado.


15.1. Apache Tomcat, soporte a JSP y Servlets.

Apache Tomcat es una implementación de las tecnologías Java Servlet y JavaServer Pages, perteneciente a la fundación de Apache, The Apache Software Foundation. Está liberada con la misma licencia que Apache, su última versión estable es la 6.0 y su página Web es http://tomcat.apache.org/.

Tomcat no es un servidor de aplicaciones como JBoss, sin embargo siendo un servidor Web soporta JSP y Servlets.

Aunque Apache es muy buen servidor Web, no soporta esta tecnología. Luego si quieres poder tener la potencia de los JSP o Servlets precisarás Tomcat o JBoss.

Tanto Apache Tomcat 6.0 como OpenJDK están soportados desde Ubuntu 8.10. Para instalarlo, simplemente teclea en la consola:


sudo apt-get install tomcat6 tomcat6-docs tomcat6-admin tomcat6-examples

Una vez instalado, haz clic en el párrafo que trata sobre los ejemplos de tomcat6-examples, más concretamente donde dice here.

Para poder acceder a la pantalla de administración, debes editar el fichero users.xml, más concretamente, teclea:

sudo gedit /var/lib/tomcat6/conf/tomcat-users.xml

Tienes que modificar ese fichero de la siguiente forma:

<?xml version='1.0' encoding='utf-8'?>

<tomcat-users>

Crea dos roles: manager y admin:

  <role rolename="manager"/>

  <role rolename="admin"/>

  <role rolename="tomcat"/>

  <role rolename="role1"/>

  <user username="tomcat" password="tomcat" roles="tomcat"/>

 <user username="both" password= "tomcat" roles= "tomcat, role1"/>

  <user username="role1" password="tomcat" roles="role1"/>

Crea un usuario con todos los roles

  <user username="joe" password="MiPassword" roles="admin, manager,tomcat"/>

  </tomcat-users>

Luego reinicia Tomcat:

sudo /etc/init.d/tomcat6 restart

. Ahora navega a la pantalla de administración en http://192.168.153.136:8080/host-manager/html e introduce joe con la palabra de paso que has indicado.

Tienes a tu disposición tanto ejemplos de Servlets como JSP. Haz clic en el primer enlace Servlets examples.

Haz clic en el enlace Execute a la derecha de Hello World, deberías ver algo como:


Para cada uno de los ejemplos, puedes lanzarlos para ver su funcionamiento haciendo clic en el enlace Execute o ver su código fuente pulsando Source.

Veamos ahora el código fuente:

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class HelloWorld extends HttpServlet {

  public void doGet(HttpServletRequest request, HttpServlet Response response)

  throws IOException, ServletException

  {

      response.setContentType("text/html");

      PrintWriter out = response.getWriter();

      out.println("<html>");

      out.println("<head>");

      out.println("<title>Hola Mundo!</title>");

      out.println("</head>");

      out.println("<body>");

      out.println("<h1>Hola Mundo!</h1>");

      out.println("</body>");

      out.println("</html>");

  }

}

15.2. Mi primer Servlet.

En esta obra sólo se pretende una mera introducción a esta tecnología. Puedes consultar las siguientes direcciones para acceder a una mayor información: http://www.tecnun.es/asignaturas/Informat1/ayudainf/aprendainf/ JavaServlets/servlets.pdf, http://www.programacion.net/java/tutorial/servlets_ jsp/ y http://java.sun.com/j2ee/1.4/docs/tutorial/doc/index.html.

Lo primero que debes observar es que la clase HelloWorld es una subclase de una clase más general llamada HttpServlet. Esta clase implementa la interfaz genérica Servlet (javax.servlet.Servlet) que es el punto de partida de cualquier Servlet. La idea que subyace a esta programación es expandir la capacidad de tu servidor de comunicarse con los clientes siguiendo un modelo de programación de solicitud respuesta. HttpServlet proporciona métodos como doGet y doPost para manejar servicios específicos HTTP.

Observa el método doGet tiene dos parámetros, el primero HttpServletRequest contiene toda la información que se envía desde el cliente a nuestro servidor y el segundo HttpServletResponse contiene la información que se envía de respuesta al cliente desde el servidor.

En este primer ejemplo, el Servlet no recoge ninguna información del cliente, simplemente va a devolver una página HTML al cliente. Observa que el objeto response es el “alma” de la fiesta. Más concretamente es un objeto de la clase HttpServletResponse y se invoca al método setContentType para informar que se va a enviar una página HTML.

Además cuando invocamos al método getWriter obtenemos un flujo o stream para poder escribir los datos de salida, en nuestro caso el código HTML. Luego mediante llamadas sucesivas al método println escribimos en dicho flujo de salida nuestra página HTML, por supuesto esta página podrías modificarla a tu gusto. Utiliza el capítulo de HTML para realizar cambios en dicho código y ver tus primeros Servlets.

Un servlet tiene varios momentos en su vida: (1) Inicio. El servidor carga el servlet y ejecuta su método init, (2) Interacción con los clientes, atención a sus peticiones, mediante el método service,(3) El servidor destruye el servlet invocando al método destroy. Para un servlet los métodos init y destroy son llamados una sola vez, mientras que service muchas veces. HttpServlet extiende la funcionalidad de un Servlet y sobrescribe el método service() de tal forma que cuando el cliente realiza una solicitud HTTP, típicamente get o put se llamará al método doGet o doPut respectivamente.

Para compilarlo deberás cambiar la variable de entorno CLASSPATH, en el fichero .bashrc, escribe al final de dicho fichero la siguiente sentencia:

export CLASSPATH=/usr/share/tomcat6/lib/servlet-api.jar.

Para compilar Servlets estos utilizan los paquetes javax.servlet.* estos se encuentran en el fichero servlet-api.jar (observa los import en las primeras líneas del Servlet de ejemplo), y con CLASSPATH indicas al compilador de Java donde encontrarlos. Luego, para compilarlo ejecuta como siempre:

javac HelloWorldExample2.java.

Sin embargo, no hemos acabado, ahora tienes que desplegarlo o integrarlo en Tomcat, básicamente decirle a Tomcat donde se encuentran. Vamos a mostrar como Tomcat ha realizado esto y como podemos modificarlo. En particular, los ejemplos que nos proporcionan se encuentran en /usr/share/tomcat6-examples/ bajo la carpeta examples. Existen una serie de directorios:

* index.html. Donde nos muestra la pantalla principal que hemos visto con anterioridad.

* jsp: una carpeta con los códigos jsp de ejemplo.

* servlets: una carpeta con los códigos servlets de ejemplo.

* WEB-INF. Esta carpeta contiene a su vez una serie de directorios, a saber: classes (las clases compiladas, es decir, .class como el HelloWorldExample.class), lib (jstl.jar, estandar.jar, librerías necesarias) y lo más importante un fichero llamado web.xml.

Una vez compilado nuestro Servlet en el directorio home de nuestro usuario, vamos a integrar nuestro ejemplo en este proyecto. Copia el fichero compilado al directorio classes, sitúate en este directorio y escribe:

sudo cp /home/joe/ MiServlet.class.

El punto final indica que lo copie precisamente en este directorio classes.

Luego añade el siguiente código en las secciones correspondientes, en el fichero web.xml

sudo vi /usr/share/tomcat6-examples/examples/ WEB-INF.

Aquí es donde registramos, damos de alta o indicamos a Tomcat donde se encuentran nuestros servlets.

<servlet>

El nombre del servlet:

<servlet-name> MiServlet </servlet-name>

La clase del servlet, en proyectos grandes deberías seguir la convención siguiente: com.micompañia.miproyecto, obviamente la organización de los directorios iría en consonancia WEB-INF, classes, com, micompañia, miproyecto.

<servlet-class> MiServlet </servlet-class>

</servlet>

<servlet-mapping>

Ahora indicamos a Tomcat como mapear una URL que el cliente escribirá en el navegador, al Servlet que acabamos de crear:

<servlet-name> MiServlet </servlet-name>

<url-pattern>/servlets/servlet/ MiServlet </url-pattern>

</servlet-mapping>

Vamos a crear un Servlet que sirva las peticiones de un formulario HTML. Este es el escenario más común. Un formulario HTML recoge los datos a través de una serie de campos, en nuestro ejemplo: nombre, email, e invoca al Servlet. Este Servlet procesa dicha información y responde al cliente mediante una página dinámica.

<HTML>

<HEAD>

<TITLE> Alta de un nuevo cliente </TITLE>

<HEAD>

<BODY>

La próxima línea es muy importante, aquí indicamos el Servlet y el método (POST) que vamos a invocar. Observa que lo hemos incluido dentro de la carpeta examples que viene con Tomcat para facilitarnos el trabajo, en un entorno real deberás crearte tu propia carpeta para tu aplicación Web.

La diferencia entre el método GET y POST, es que con get el conjunto de datos del formulario se añaden a la URL especificada por action separados por el signo de interrogación “?”. En cambio, con POST los datos del formulario se agregan al final de la petición.

<FORM ACTION="http://localhost:8080/examples/servlets/ servlet/MiServlet" METHOD="POST">

Tenemos dos campos de texto: nombre y email, y dos botones: submit y reset. Fíjate en el atributo NAME que precisarás más tarde para recuperar dicha información.

Nombre: <INPUT TYPE="TEXT" NAME="nombre" SIZE=20><BR>

E-mail: <INPUT TYPE="TEXT" NAME="email" SIZE=20><BR>

El botón submit al activarse envía el formulario, el reset borra la información suministrada por el usuario:

<INPUT TYPE="SUBMIT" NAME="Enviar" VALUE="Enviar">

VALUE="Limpiar">

</FORM>

</BODY>

</HTML>

import java.io.*;

import java.util.*;

import javax.servlet.*;

import javax.servlet.http.*;

/**

* Nuestro primer servlet.

*

* @author Maximo y Javier

*/

public class MiServlet extends HttpServlet {

  public void doPost(HttpServletRequest request,

        HttpServletResponse response)

    throws IOException, ServletException

{

Nuestra respuesta será una página HTML

response.setContentType("text/html");

Obtenemos un flujo de salida para escribir dicha página.

PrintWriter out = response.getWriter();

Escribimos en dicho flujo los distintos elementos de una página HTML.

out.println("<html>");

out.println("<head>");

out.println("<title>" + "Mi primer Servlet" + "</title>");

out.println("</head>");

out.println("<body>");

Observa en esta línea como recuperamos la información del formulario, los datos enviados por el formulario están encapsulados en el objeto request de la clase HttpServletRequest.

Esta clase tiene un método llamado getParameter (no puede ser más descriptivo, obtener parámetro), al que se le pasa como argumento el nombre del parámetro indicado con el atributo NAME.

out.println("Gracias, " + request.getParameter("nombre") + " por tu respuesta.");

    out.println("<br>");

  out.println ("Nos pondremos en contacto en tu email" + request.getParameter("email")+ " a la mayor brevedad posible");

    out.println("</body>");

    out.println("</html>");

    out.close();

  }

}

Observa finalmente a la izquierda el formulario HTML y a la derecha la respuesta del Servlet a dicha información.


15.3. Primeros pasos con JSP.

JSP son las siglas de Java Server Pages, la idea que subyace a esta técnica de programación es separar la parte estática HTML de la dinámica. El código JSP empieza escribiendo <% y termina cerrándose con %>. El resto será código HTML, de todas formas no te dejes engañar, este código JSP será convertido a un Servlet y el código estático HTML se mostrará por el flujo de salida asociado con el método service del servlet (al que se convertirá tu JSP).

¿Cuándo todo esto sucede? La primera vez que se llame o invoque a dicho JSP, luego puede haber una pequeña demora la primera vez que se lance respecto al resto de ejecuciones. Por tanto, en un entorno de explotación debes comprobar que todos tus JSP estén ejecutados previamente, para evitar esperas a tus clientes.

Nosotros daremos prioridad a los JSP sobre los Servlets, la razón es sencilla, normalmente un JSP podría ser encargado a un Webmaster, al fin y al cabo integra tanto HTML como código Java. Sin embargo, los objetos de negocio como EJB, Java Beans o incluso Servlets son realizados normalmente por el programador.

Vamos a crear una carpeta en /usr/share/tomcat6-examples/ llamado miJsp en el editaremos un fichero miJsp.jsp, escribe lo siguiente:

<html>

<head><title>Mi Primer JSP</title></head>

<body>

<% out.println("Hola mundo"); %>

</body>

</html>

Observa que es el mismo resultado que habíamos realizado con Servlets.Pero veamos algo más, añade la siguiente línea:

Fecha actual: <%= new java.util.Date() %>

para mostrar la fecha del sistema.

Desde tu código JSP existen un conjunto de variables predefinidas que puedes usar. Las más importantes son:

* request: HttpServletRequest, encapsula la petición del cliente: tipo de petición (GET/POST), parámetros, etc.

* response: HttpServletResponse, encapsula la respuesta del servidor

* session: HttpSession, las sesiones nos permiten manejar información de estado en esta comunicación cliente-servidor, es decir, permite mantener información del cliente entre diferentes peticiones. Un ejemplo sería comprobar si el usuario está autentificado o no.

* out: JspWriter, con el que escribimos los datos al flujo de salida para enviar información a los clientes.

Un ejemplo de utilización de estas variables sería conocer cual es la dirección IP del cliente, esto se consigue con el siguiente código:

<%= request.getRemoteHost() %>

Esto es una simple expresión JSP que escribe directamente sobre la salida. Además vamos a incluir una directiva include en nuestro siguiente ejemplo.

En particular que incluya import el paquete java.util.* necesario para la función Date:


<%@ page import="java. util.*" %>

<%@ page contentType ="text/html;charset=UTF-8" %>

<%@ page import="java.util.*" %>

<html>

<head><title>Mi Primer JSP</title></head>

<body>

&<% out.println("Hola Mundo"); %><br>

Fecha actual: <%= new Date() %><br>

IP de tu equipo: <%= request.getRemoteHost() %>

</body>

</html>

Otra directiva sería especificar el formato de la salida, contentType en nuestro caso text/html:

<%@ page content Type="text/html; charset=UTF-8”>

Fíjate en el resultado que hemos obtenido en la figura adjunta.

Vamos a hacer algo más, vamos a enviarle datos a nuestro JSP. Esto se realiza utilizando la siguiente sintaxis: http://servidor/Servlet.jsp?nombreParámetro=valorParámetro.

Este es el código que recupera dicho parámetro, observa que invocamos al método getParameter del objeto request de la clase HttpServletRequest:

<%out.println ("Hola "+request. getParameter ("nombre")); %>

Avancemos un poco más, vamos a introducir como parámetro la edad y en función de si es mayor de edad o no, nos devolverá un resultado distinto.


<%@ page contentType="text/html; charset=UTF-8" %>

<html>

<head><title>Mi Primer JSP</title></head>

<body>

<% out.println("Hola " + request.getParameter("nombre") + " " );

int edad = Integer.parseInt(request.getParameter("edad"));

if (edad<18) { %>

eres menor de edad

<% } else { %>

eres mayor de edad

<% } %>

</body>

</html>

Obsérvese que primero realizamos una conversión de entero a cadena mediante la invocación al método de clase parseInt. Le pasamos como argumento el segundo parámetro que el cliente introducirá, su edad. ¡Ten en cuenta que los parámetros los recibimos como cadena! Además los parámetros se separan por el carácter “&”.

Otra alternativa más elegante desde nuestro punto de vista sería la que se muestra en la figura.

<%@ page contentType="text/html; charset=UTF-8" %>

<html>

<head><title>Mi Primer JSP</title></head>

<body>

<% out.println("Hola " + request.getParameter("nombre") + " " );

int edad = Integer.parseInt(request.getParameter("edad"));

if (edad<18) {

String redireccion="http://www.google.es";

response.sendRedirect(redireccion);

} else {

out.println("eres mayor de edad");

} %>

</body>

</html>

Todo el código que maneja la lógica es Java.

En este caso, utilizamos el método println de out para los mayores y a los menores de edad los redireccionamos a Google mediante el método sendRedirect del objeto response (HttpServletResponse).


15.4. Separando la interfaz de la capa de negocio con Java Beans.

La tecnología JavaBeans está basada en un modelo por componentes. Estos componentes son unidades reutilizables de código llamados “beans” que implementan la lógica de negocio.

Observa que la capa de interfaz se debería encargar única y exclusivamente de la interacción con el usuario. En un entorno productivo utilizaremos JavaBeans para el procesamiento de la información, incluso en un entorno distribuido EJB, donde podremos invocar a componentes que están ubicados remotamente. Éstos implementarán la lógica de la aplicación Web, es decir, aquí es donde se va a realizar propiamente el procesamiento de la información, accesos a las bases de datos,etc.

Veamos a continuación como crear un JavaBean muy simple y luego como lo llamaremos desde nuestro JSP.

Lo primero en que debes fijarte es que creamos un paquete que contiene todos nuestros JavaBeans, llamado misBeans. En un entorno productivo querrás utilizar algo como:


package com.micompañia.miproyecto.misBeans

package misBeans;

public class Usuario implements java.io.Serializable

{

Nuestra clase Usuario tendrá tres atributos: nombre, edad y dirección IP (dirIP):

private String nombre;

private int edad;

private String dirIP;

Deberemos suministrar además del constructor normal, uno vacío

public Usuario () {}

  public Usuario (String nombre, int edad, String dirIP)

  { this.nombre=nombre;

    this.edad=edad;

    this.dirIP=dirIP;

   }

     public String getNombre() { return nombre;}

     public int getEdad() { return edad;}

     public String getIP() { return dirIP;}

  public void setNombre(String nombre) { this.nombre= nombre;}

    public void setEdad(int edad) {this.edad=edad;}

     public void setIP(String ip) {this.dirIP=ip;}

     public String redireccionar() {

     if (edad>18) return "http://www.google.es";

     else return "http://www.terra.es";

     }

}

Un JavaBean se caracteriza por los siguientes elementos: propiedades (nombre, edad, dirIP), un constructor vacío (public Usuario(){}), métodos Get y Set para obtener y actualizar las propiedades o atributos (p.e. getNombre, setNombre). Además implementa la interfaz Serializable, aunque esto no es realmente necesario y puede tener otros métodos, en nuestro ejemplo redireccionar.

Este método redireccionar en función de la edad del sujeto envía una cadena distinta. Fíjate como podrías en función de una serie de parámetros: país de procedencia de la dirección IP, alta en una base de datos, edad, números de accesos, etc. decidir si permitir al usuario o no el acceso a tu Web. Como ves, conforme la lógica de negocio se va complicando, más fácil será escribir, mantener y reutilizar código cuando dicha lógica se separa de la lógica de interfaz. Veamos ahora el código del JSP que invoca al JavaBean.


<HTML>

<HEAD>

<TITLE>Utilizando JavaBeans en un JSP</TITLE>

</HEAD>

<BODY>

Esta es la línea principal, donde se define que vamos a utilizar una clase llamada Usuario del paquete misBeans, además le asignaremos un identificador, en el ejemplo miUsuario. Observa que a partir de ahora miUsuario es un objeto de la clase Usuario, se ha creado llamando al contructor vacío (sin argumentos). También conviene resaltar que dicho objeto se ha invocado y está disponible en el WebServer, en Tomcat, es así pues local.


<jsp:useBean id="miUsuario" class="misBeans.Usuario" />

//En esta línea se declara e instancia un objeto miUsuario.

Seguidamente podemos invocar a los métodos setNombre, setEdad, setIP para definir sus propiedades. Luego llamamos al método getClass que devuelve la clase del objeto y getName que muestra una cadena que representa dicha clase.

<% miUsuario.setNombre("Marta");

    miUsuario.setEdad(15);

    miUsuario.setIP("23.24.111.23");

%>

Hemos creado una instancia de la clase: <%=miUsuario.getClass().getName() %>

<br>

También llamamos, por motivos pedagógicos exclusivamente a los métodos getNombre y getEdad. Mucho más interesante es observar como ahora creamos un link en función de la cadena que nos devuelve el objeto miUsuario al llamar al método redireccionar.

La edad del usuario: <b><%=miUsuario.getNombre() %></b>

es <%=miUsuario.getEdad() %>

<a href= <%=miUsuario.redireccionar() %>>Tu enlace</a>

</BODY>

</HTML>

Este es el resultado final, si el usuario hace clic sobre el hipervínculo Tu enlace, será redireccionado a http://www.terra.es, pues es menor de edad (tiene 15 años). La lógica que crea la dirección URL está implementada en Usuario, mientras que el que finalmente crea el código HTML con el enlace es el JSP.

Para integrar nuestros JavaBeans en Tomcat debemos realizar dos pasos previos:

1) Compilarlos:

javac Usuario.java

2) Copiarlos al directorio classes de nuestro proyecto, en nuestro ejemplo:

sudo cp Usuario.class/usr/share/tomcat6-examples/ examples/WEB-INF/classes/misBeans




Ten en cuenta que como hemos definido un paquete llamado misBeans, el fichero Usuario.class deberás copiarlo no directamente en el directorio classes sino en un subdirectorio misBeans de este. Si hubieras creado un paquete como com.micompañia.miproyecto.misBeans, tendrías que crear varios subdirectorios dentro de classes:

com

….micompañia

……..miproyecto

………….misBeans

Casi todo en la vida tiene un precio, en este caso una mejor organización puede inicialmente percibirse como un incremento de la complejidad, pero cuando dicho código crece, reconocerás que es mucho más manejable.


15.5. JBoss, un servidor de aplicaciones Open Source.

JBoss es una alternativa a Tomcat, en este caso estamos hablando de un servidor de aplicaciones Open Source, es decir, ofrece servicios tales como persistencia, transacciones, mensajería y clustering. Para más información visita la página Web oficial, http://www.jboss.org/projects/. La instalación es bastante más complicada de lo que solemos estar acostumbrados.

1)Descarga de http://www.jboss.org/jbossas/downloads/ la versión estable más reciente, en este momento era la 4.2.3.GA. Descomprímelo

unzip jboss-4.2.3.GA.zip)

y guárdalo en /usr/local (renómbralo a /jboss).

2) Edita tu fichero .bashrc o mejor el /etc/profile y escribe lo siguiente:

export JAVA_HOME=/usr/lib/jvm/java-6-sun-1.6.0.10/

export PATH=$PATH:$JAVA_HOME/bin

export ANT_HOME=/usr/ant/apache-ant-1.6.0

export PATH=$PATH:$ANT_HOME/bin

export JBOSS_HOME=/usr/local/jboss

export PATH=$PATH:$JBOSS_HOME/bin

Estamos definiendo tres variables de entorno: JAVA_HOME, PATH y JBOSS. Para comprobar los cambios, ejecuta .bashrc y pregunta sobre algún valor, por ejemplo teclea en la consola: echo $JBOSS.

3) Para lanzarlo nos dirigimos al directorio de JBOSS, dentro de bin y ejecutamos:

./run.sh

Para pararlo:

./shutdown.sh –S

4) Si quieres crear un script que automatice este proceso realiza lo siguiente:

a) añade un usuario y un grupo jboss:

groupadd jboss; useradd –g jboss –m jboss; passwd jboss

b) crea el fichero:

sudo touch /etc/init.d/jboss;

c) hazlo ejecutable:

sudo chmod a+x /etc/init.d/jboss;

d) y escribe lo siguiente:

#! /bin/sh

# /etc/init.d/jboss

ECHO=/bin/echo

Este es el script de arranque:

start() {

$ECHO -n "Iniciando JBoss"

Cambiamos de usuario a jboss (opción l) y ejecutamos run.sh(-c)

su -l jboss -c '/usr/local/jboss/bin/run.sh > /dev/null &'

$ECHO "."

}

Este sería el script de parada:

stop() {

$ECHO -n "Parando JBoss"

su -l jboss -c '/usr/local/jboss/bin/shutdown.sh -S &'

$ECHO "."

}

Cuando lanzas el script ejecutas /etc/init.d/jboss orden. Observa que $0 es el propio script (es decir la cadena “jboss”). $1 es una de las siguientes órdenes:

* start, en cuyo caso ejecutaremos start().

* stop, ejecutaremos stop()

* restart: paramos, esperamos e iniciamos

* “Cualquier cosa”, la opción * significa “todo lo demás”, el usuario se ha equivocado y le ofrecemos una ayuda online.

case "$1" in

start)

start

;;

stop)

stop

;;

restart)

stop

sleep 30

start

;;

*)

$ECHO "Usa: jboss {start|stop|restart}"

exit 1

esac

exit 0

Finalmente podrías querer que JBoss se inicie en tiempo de arranque, en este caso debes ejecutar:

update-rc.d jboss defaults.


15.6. Accediendo a bases de datos con JDBC.

Para poder utilizar cualquier base de datos debes instalar un controlador de dicha base de datos para poder conectarte a ella y utilizarla. En Ubuntu instala el paquete libmysql-java:

sudo apt-get install libmysql-java.

En otras instalaciones o Windows, visita http://dev.mysql.com/downloads/, la sección Connectors, Connector/J.

Para realizar las primeras pruebas te aconsejamos que copies el fichero, mysql-connector-java-5.1.6-bin.jar a tu directorio HOME, lo renombres a algo más manejable, por ejemplo mysql.jar y añadas dicho fichero en la variable de entorno CLASSPATH:

export CLASSPATH=.:/home/joe/misLibrerias/mysql.jar

Observa que un fichero .jar no es más que una colección de paquetes y clases agrupadas en un único fichero para simplificar su distribución, en todo momento puedes consultar su contenido con la siguiente sintaxis:

jar tf nombreFichero.jar

Ahora vamos a crear un primer ejemplo de JDBC, crearemos un fichero llamado TestMybd. Luego lo compilaremos como siempre:


javac TestMybd.java

Y ejecutaremos:

java TestMybd

En primer lugar indicamos que las clases que vamos a necesitar se encuentran dentro del paquete java.sql.

import java.sql.*;

public class TestMybd {

public static void main(String args[]) {

Connection myconexion=null;

Statement consulta=null;

try {

String driver = "com.mysql.jdbc.Driver";

System.out.println("=> Cargando el driver..." );

En segundo lugar cargaremos el driver, observa que como argumento le pasamos com.mysql.jdbc.Driver y que está dentro de un bloque try … catch.

Una excepción está concebida para que en caso de error, la aplicación no se muera sino que lance, throwuna excepción.

Esta excepción será capturada, catch y se realizará la acción pertinente. Idealmente podríamos recuperarnos del error, en la práctica normalmente sólo mostrarás al usuario lo que ha pasado, llamando al método printStackTrace y finalizarás la ejecución del programa.

Class.forName(driver );

System.out.println("=>Driver cargado" );

String url = "jdbc:mysql://localhost/mibd";

System.out.println("=> Conectando a la base de datos…" );

La siguiente parte importante es la relativa a la conexión a la base de datos propiamente dicha. Debes suministrar los siguientes argumentos:

* Dirección o url: jdbc:mysql://dirIPServidor/nombreBaseDatos. Esta base de datos deberá ser creada previamente con la sentencia CREATE DATABASE nombreBaseDatos.

* Nombre usuario. También debes haber creado el usuario y haberle dado (grant) los permisos (normalmente todos) sobre dicha base de datos.

* Contraseña del usuario.

myconexion = java.sql.DriverManager.getConnection(url, "myuser", "mycontraseña" );

System.out.println("=>Conectado a la base de datos" );

}

catch(Exception e ) {

e.printStackTrace();

}

try {

Ahora obtendremos el objeto Statement, ese será el que envíe nuestras sentencias SQL al controlador.

consulta = myconexion.createStatement();

Para ejecutar sentencias SQL relativas a la creación de tablas, inserción/modificación/ eliminación de tuplas en las tablas ejecutaremos el método executeUpdate, para consultas SQL utilizaremos executeQuery. En el ejemplo, primero crearemos la tabla Usuarios, luego insertaremos el usuario Pedro y luego ejecutaremos una consulta SQL para recuperar los usuarios.

Como podrás comprobar es un ejemplo muy básico pero pensamos que debes seguir el siguiente principio: Un largo camino comienza en un primer paso. Éste debe ser tu primer paso para realizar programas Java que utilicen MySQL.

consulta.executeUpdate("CREATE TABLE Usuarios " +

"(COD_CLIENTE INTEGER PRIMARY KEY, NOMBRE VARCHAR(30), EMAIL VARCHAR(30), " +

" DIRIP VARCHAR(20), EDAD INT)");

consulta.executeUpdate("INSERT INTO Usuarios " +

"VALUES (1,'Pedro', 'pedro@gmail.com','32.32.34.123',12)");

String select = "SELECT * FROM Usuarios";

Ejecutar una consulta requiere un poco más de trabajo. Observa que el método que llamamos es executeQuery que nos devuelve un objeto rs de la clase ResultSet. Este objeto rs contendrá toda la funcionalidad necesaria para poder recuperar toda la información devuelta por MySQL como resultado de nuestro SELECT.

ResultSet rs = consulta.executeQuery(select);

Nuestro objeto rs tiene un método llamado next que permite al cursor (entiéndelo como un puntero o apuntador) navegar por el resultado de la consulta, obteniendo todas las filas o tuplas resultados.

while(rs.next())

{

Luego recuperamos de cada fila todos los atributos que les habíamos indicado en nuestra consulta SELECT con los métodos adecuados, dependiendo si el atributo es un entero (getInt), una cadena (getString), etc. Observa que todos estos métodos deben tener como argumento el nombre del campo o atributo.

System.out.println("CodCliente:" + rs.getInt("COD_CLIENTE"));

System.out.println("Nombre: " + rs.getString("NOMBRE"));

System.out.println("Email: " + rs.getString("EMAIL"));

System.out.println("DirIP: " + rs.getString("DIRIP"));

System.out.println("Edad: " + rs.getInt("EDAD"));

}

} catch (SQLException e) {

e.printStackTrace();

}

}

}

Finalmente puedes comprobar el resultado de la ejecución de nuestro programa.


15.7. Muchas tecnologías a tu alcance: Java Mail, RMI, JNDI, JNI, Java2D, Java3D, Hibernate.

Primero debes de considerar que Java ha desarrollado soluciones para tres ámbitos:

* Java 2 Standard Edition, para realizar aplicaciones y applets.

* Java 2 Enterprise Edition para el entorno empresarial. Nos encontramos que el software no es ejecutado en un sólo equipo sino en una red de ordenadores, se utilizan EJBs distribuidos.

* Java 2 Micro Edition para el desarrollo de aplicaciones para dispositivos con “limitaciones” tales como teléfonos móviles, PDA o electrodomésticos inteligentes. En estos equipos nos encontramos con pequeñas pantallas o escasez de memoria entre otras restricciones.

Existen además muchas posibilidades y tecnologías a tu alcance, indicamos algunas:

* RMI: Remote Method Invocation, invocación de métodos remotos. Nos permite llamar desde nuestro programa java a métodos de otro programa o incluso que estén ejecutándose en otra máquina distinta.

* JNDI: Java Naming and Directory Interface, es una API que permite a los clientes descubrir objetos a través de un nombre, es decir, nos permite acceder a los servicios de directorio de LDAP, DNS, etc.

* JNI: Java Native Interface, permite a nuestro programa Java poder comunicarse e interactuar con otros programas escritos en diferentes lenguajes, como por ejemplo, C, C++, etc.

* JavaMail, es una API que nos proporciona funcionalidades de correo electrónico tales como: enviar, leer y componer mensajes, añadir archivos adjuntos, etc.

* JMS, Java Message Service, proporciona a las aplicaciones la capacidad para crear, enviar, recibir y leer mensajes.

* Java 2D amplia las capacidades gráficas de AWT (Abstract Windows Toolkit) para la creación de una mejor experiencia de usuario con mejores interfaces. Para gráficos 3D contamos con Java 3D, permite crear y manipular objetos en tres dimensiones así como crear universos virtuales en una amplia variedad de tamaños desde astronómicos a subatómico.

* Hibernate, supera la diferencia entre el modelo de datos orientado a objetos de tu programa y el modelo relacional que encuentras en las bases de datos. Cuando utilizas Hibernate manipulas los datos de tu base de datos operando sobre objetos.

Nos dejamos muchas en el tintero, pero creemos que te puedes hacer una idea del enorme potencial de Java, su estudio más detallado supera las pretensiones de esta obra.


15.8. Otras alternativas: Perl, Python y Ruby.

Perl es un lenguaje de programación que ha tenido cierto éxito y que siempre ha sido elogiado por su potencia a la hora de procesar texto. Perl ha sido utilizado para realizar CGI scripts en servidores Web, tales como: contadores, libros de visitas, etc. Un tutorial muy interesante llamado Beginner’s Guide to CGI Scripting with Perl, lo puedes encontrar en http://www.lies.com/begperl/.

Para poder ejecutar código CGI en Apache, primero debes instalar el paquete libapache2-mod-perl2:

sudo apt-get install apache2 libapache2-mod-perl2

Cuando instalas Apache, existen varios subdirectorios del principal /etc/apache2. En particular nos interesa sites-available (sites disponibles), este directorio contiene un conjunto de ficheros para poder administrar distintos sites o Webs. Por defecto encontrarás el archivo default que es la Web que viene por defecto. Luego para utilizar Perl debemos editar dicho fichero para configurar nuestra Web, escribe en la consola:

sudo vi /etc/apache2/ sites-available/default

Debes buscar la siguiente sección y asegúrate de dejarla sin comentarios (las almohadillas “#” al principio de cada línea) y tal como aparece en las siguientes líneas:

ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/

Indica que cuando el servidor reciba una petición como http://www.mydominio.com/cgi-bin/micgi.cgi, lo redirija al directorio /usr/lib/cgi-gin.

Ahora especificamos las opciones de configuración de dicho directorio.

<Directory "/usr/lib/ cgi-bin">

Configuramos la opción que permite la ejecución de scripts CGI.

Options +ExecCGI

La siguiente opción indica que los ficheros con extensión.cgi van a ser ejecutables CGI. La sintaxis es: AddHandler nombre_manejador extensión [extensión], en nuestro ejemplo el nombre del manejador es cgi-script.

AddHandler cgi-script .cgi

</Directory>

Obviamente el siguiente paso será reiniciar apache:

sudo/etc/init.d/apache2 restart

Ahora escribamos nuestro primer programa Perl. Escribe en la consola:

sudo vi /usr/lib/cgi-bin/HolaPerl.cgi

y escribe el siguiente programa:

La primera línea indica dónde se encuentra el intérprete de Perl.

#!/usr/bin/perl

use strict;

La siguiente indica el tipo de contenido:

print "Content-type: text/html\n\n";

Finalmente escribimos el típico Hola Mundo con print:

print ‘Hola Perl’;

Es importante que recuerdes hacerlo ejecutable:

sudo chmod a+x HolaPerl.cgi

Observa la llamada al programa: http://servidor/cgi-bin/HolaPerl.cgi

Ahora vamos a centrarnos en realizar un contador en Perl:

#!/usr/bin/perl

use strict;

print "Content-type: text/html\n\n";

La primera línea nueva es la que abre el fichero miContador.txt en modo lectura. Observa que dicho fichero debe también encontrarse en el mismo directorio /usr/lib/cgi-bin/ y tener permisos de ejecución:

sudo chmod a+x miContador.txt

Dicho archivo tendrá ahora un manejador en nuestro programa llamado myManejador.

open (myManejador, "miContador.txt");

Creamos una variable contador y leemos el número que se encuentra en nuestro fichero y lo almacenamos en la variable contador. Observa que como hemos utilizado use strict, debemos declarar las variables antes de usarlas. La idea es tratar de prevenir errores y conseguir un software más seguro.

my($contador) = < myManejador >;

Cerramos el fichero porque tendremos que abrirlo después en modo escritura.

close myManejador;

Incrementamos nuestro contador.

$contador = $contador + 1;

Abrimos el fichero en modo escritura.

open (myManejador, "> miContador.txt");

Escribimos en dicho fichero nuestra variable contador.

print myManejador "$contador";

Una mejora que dejamos para el lector es que en vez de mostrar un número utilice imágenes para mostrar el número de accesos.

Cerramos el fichero.

print myManejador "$contador";

Mostramos por pantalla el contador.

print "$contador";

exit;

Ruby es un lenguaje de programación orientado a objetos “open source”, interpretado y reflexivo. Si eres usuario de Windows, la manera más fácil de instalarlo es desde http://rubyinstaller.rubyforge.org/wiki/wiki.pl, que contiene un auto instalador de “1 clic”. En Ubuntu escribe:

sudo apt-get install ruby rubygems irb ri rdoc ruby1.8-dev build-essential

Entra en ambos casos en la consola y escribes:

irb

La instalación que hemos mostrado en Ubuntu es la más rápida pero puedes tener problemas si quieres “algo más” que un simple vistazo, visita la siguiente URL para más información: http://wiki.rubyonrails.org/rails/pages/RailsOnUbuntu.

Observa en la figura que calculamos el factorial de 7. Además hemos aprovechado para escribir el típico hola mundo, pero libre, ¿eh? Hemos creado realmente un método, definido por la palabra “def” seguida del nombre del método y los parámetros. El método debe terminar con la palabra “end”.

Ruby on Rail se presenta como una solución productiva para el desarrollo de aplicaciones Webs. Presenta una arquitectura MVC:

* M, Models: es el modelo, representa los datos, la información, así como las reglas para manipular los datos.

* V, Views: representa la interfaz de la aplicación, está formado por código Ruby insertado en ficheros HTML de forma similar a lo que hemos visto con los JSP.

* C, Controllers: es lo que hemos llamado otras veces capa de negocio, luego tenemos tres capas: datos, vistas y negocio. Este nivel se encarga de procesar las peticiones de los clientes Web, interaccionar con el Modelo para recuperar los datos necesarios y devolver la información ya procesada a la capa Views para su presentación al usuario.

Visita http://guides. rubyonrails.org/, para una información más detallada. Para empezar realiza los siguientes pasos:

1. Instala el paquete ruby.

2. Luego crea la aplicación myapp: rails myapp. Te creará una carpeta myapp y dentro de esta un directorio app que contendrá los controladores, modelos y vistas de tu aplicación.

3. Navega a la carpeta myapp y crea el controlador y la vista: script/generate controller home index.

Desde nuestra carpeta myapp, en la consola teclea:

sudo vi app/views/ home/index.html.erb.

Escribe en dicho fichero lo siguiente:

<h1>Hola Rails</h1>

Navega a http://localhost:3000/home/index y podrás ver la página recién creada.

4. Arranca el servidor Web de Rails:script/server. Para parar el servidor Ctrl.+ C

5. Finalmente navega a http://localhost:3000 para comprobar que todo funciona.


Observa que hemos creado una sencilla aplicación, un blog, siguiendo las directrices de: http://guides.rubyonrails.org/getting_started_with_rails.html.

Python es un lenguaje muy de moda, en Linux no tienes ni que instalarlo basta con invocarlo escribiendo python en la consola. Si eres usuario de Windows puedes descargarte el instalador de la página oficial http://www.python.org/, http://docs.python.org/tutorial/.

Es un lenguaje orientado a objetos que ofrece una gran integración con otros lenguajes de programación y herramientas de desarrollo.

Volvemos a calcular el factorial de 7 y a mostrar un mensaje, pero esta vez en Python sobre Linux.

Para hacer un programa gráfico precisas instalar el paquete: python-tk. Estás instalando el módulo Tkinter, interfaz Python a las Tk GUI.

Extremos de su manual en http://www.pythonware.com/library/ tkinter/introduction/book-index.htm, una versión del Hola Mundo.

Escribe en la consola:

sudo vi holaMundo.py

y teclea lo siguiente:

from Tkinter import *

root = Tk()

w = Label(root, text="Hola Mundo!")

w.pack()

root.mainloop()

Un entorno integrado de desarrollo para Python es IDLE, sólo tienes que instalar el paquete idle.

Edita un fichero con gedit, vi, emacs, etc. Luego lo abres desde el entorno con File, Open. Finalmente, lo ejecutas desde Run, Run Module o F5.

Para mayor información sobre IDLE visita: http://hkn.eecs.berkeley.edu/~dyoo/ python/idle_intro/IDLE_spanish.html.

Para utilizar Python dentro de Apache tendrás que instalar el paquete: libapache2-mod-python.

Lánzalo con:

python holaMundo.py

Una buena guía de instalación la encontrarás en: http://www.howtoforge.com/embedding-python-in-apache2-with-mod_python-debian-etch . Si quieres ejecutar Python desde Apache tienes que volver a editar el fichero:

vi /etc/apache2/sites-available/ default

y asegurarte de dejarlo así:

<Directory /var/www/>

Options Indexes FollowSymLinks MultiViews

AllowOverride AuthConfig

Order allow,deny

allow from all

El nuevo manejador de ficheros .py es mod_python

AddHandler mod_python .psp

PythonHandler mod_python.psp

PythonDebug On

</Directory>

Tendrás que reiniciar Apache:


sudo /etc/init.d/apache2 restart

Ahora escribiremos nuestro típico ejemplo Hola Python, escribe:

sudo vi /var/www/test.psp

con el siguiente código:

<html>

<body>

<h1><% req.write("Hola Python!") %></h1>

</body>

</html>

Observa la similitud con JSP, para más información sobre Python como lenguaje de programación para la Web consulta la siguiente dirección: http://www.modpython.org/live/current/doc-html/modpython.html